{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(600, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 05. Soft Actor Critic (SAC)\n",
    "\n",
    "1. [T. Haarnoja et al., \"Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor.\" arXiv preprint arXiv:1801.01290, 2018.](https://arxiv.org/pdf/1801.01290.pdf)\n",
    "2. [T. Haarnoja et al., \"Soft Actor-Critic Algorithms and Applications.\" arXiv preprint arXiv:1812.05905, 2018.](https://arxiv.org/pdf/1812.05905.pdf)\n",
    "\n",
    "The main purpose of SAC is to maximize the actor's entropy while maximizing expected reward. We can expect both sample efficient learning and stability because maximizing entropy provides a substantial improvement in exploration and robustness.\n",
    "\n",
    "As an extension of standard RL's objective function $\\sum_t \\mathbb{E}_{(s_t, a_t) \\sim \\rho_\\pi} [r(s_t, a_t)]$, let's consider a more general maximum entropy objective which favors stochastic policies by augmenting the objective with the expected entropy of the policy over $\\rho_\\pi (s_t)$:\n",
    "\n",
    "$$J(\\pi) = \\sum_{t=0}^T \\mathbb{E}_{(s_t, a_t) \\sim \\rho_\\pi} [r(s_t, a_t) + \\alpha H(\\pi(\\cdot | s_t))].$$\n",
    "\n",
    "The temperature parameter $\\alpha$ determines the relative importance of the entropy term against the reward, and thus controls the stochasticity of the optimal policy. By this objective, the policy can explore more widely and capture multiple modes of near-optimal behavior. In conclusion, it considerably improves learning speed over other methods that optimize the conventional RL objective function.\n",
    "\n",
    "In the paper, the authors show that *Soft Policy Iteration* guarantees convergence based on a tabular setting (4.1), and they extend it to a practical approximation for large continuous domains (4.2). Firstly, the soft value function is trained to minimize the squared residual error:\n",
    "\n",
    "$$J_V (\\psi) = \\mathbb{E}_{s_t \\sim D} \\big[ \\frac{1}{2}(v_\\psi (s_t) - \\mathbb{E}_{a_t \\sim \\pi_\\phi} [Q_\\theta(s_t, a_t) - \\log_{\\pi_\\phi}(a_t | s_t)])^2 \\big],$$\n",
    "\n",
    "where $D$ is the distribution of previously sampled states and actions, or a replay buffer. Second, the soft Q-function parameters can be trained to minimize the soft Bellman residual:\n",
    "\n",
    "$$J_Q (\\theta) = \\mathbb{E}_{(s_t, a_t) \\sim D} \\big[ \\frac{1}{2} \\big( Q_\\theta(s_t, a_t) - \\hat{Q}(s_t, a_t) \\big)^2 \\big],$$\n",
    "\n",
    "with $\\hat{Q}(s_t, a_t) = r(s_t, a_t) + \\gamma \\mathbb{E}_{s_{t+1} \\sim \\rho} [V_{\\tilde{\\psi}} (s_{t+1})].$\n",
    "\n",
    "Finally, the policy paramameters can be learned by directly minimizing the following expected KL-divergence:\n",
    "\n",
    "$$J_\\pi(\\phi) = \\mathbb{E}_{s_t \\sim D} \\big[ D_{KL} \\big( \\pi_{\\phi} (\\cdot | s_t) \\| \\frac{\\exp(Q_{\\theta}(s_t, \\cdot))}{Z_\\theta(s_t)} \\big) \\big].$$\n",
    "\n",
    "We can rewirte the objective as\n",
    "\n",
    "$$J_\\pi(\\phi) = \\mathbb{E}_{s_t \\sim D, \\epsilon_t \\sim N} [ \\log_{\\pi_\\phi}(f_\\phi(\\epsilon_t ; s_t) | s_t) - Q_\\theta (s_t, f_\\phi (\\epsilon_t ; s_t))],$$\n",
    "\n",
    "where $\\pi_\\phi$ is defined implicitly in terms of $f_\\phi$, and the partition function is independent of $\\phi$ and can thus be omitted.\n",
    "\n",
    "One thing to note is that the authors suggest to use two Q-functions to mitigate positive bias in the policy improvement step that is known to degrade performance of value based methods. In particular, we parameterize two Q-functions, with parameters $\\theta_i$, and train them independently to optimize $J_Q(\\theta_i)$. We then use the minimum of the Q-functions for the value gradient and policy gradient. Two Q-functions can significantly speed up training, especially on harder tasks.\n",
    "\n",
    "### Can we do better?\n",
    "\n",
    "In Soft Actor Critic paper, the experiment of reward scale shows that SAC's performance quite varies depending on reward scaling. In the follow-up paper [2], the authors assume that the temperature parameter $\\alpha$ needs to be adjusted depending on the magnitude of the reward, and they define the soft policy optimization as a constrained problem.\n",
    "\n",
    "$$\\max_{\\pi_{0:T}} \\mathbb{E}_{\\rho_\\pi} \\big[ \\sum_{t=0}^T r(s_t, a_t) \\big] \\text{ s.t. } \\mathbb{E}_{(s_t, a_t) \\sim \\rho_\\pi} [-\\log(\\pi_t(a_t|s_t))] \\ge H \\text{ for all } t,$$\n",
    "\n",
    "where $H$ is a desired minimum expected entropy. This constrained maximization becomes the following dual problem.\n",
    "\n",
    "$$\\min_{a_T \\ge 0} \\max_{\\pi_T} \\mathbb{E} [r(s_T, a_T) - \\alpha_T \\log \\pi(a_t|s_t)] - \\alpha_T H,$$\n",
    "\n",
    "where $\\alpha_T$ is the dual variable. Furthermore, it can be rewrited as a optimization problem with regards to $\\alpha$.\n",
    "\n",
    "$$J(\\alpha) = \\mathbb{E}_{a_t \\sim \\pi_t} [-\\alpha \\log \\pi_t (a_t | s_t) - \\alpha H].$$\n",
    "\n",
    "By optimizing this dual problem, we can adjust the dual variable $\\alpha$, which plays the role of the temperature."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "from torch.distributions import Normal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "- collections.deque\n",
    "- list\n",
    "- numpy.ndarray\n",
    "\n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of Get item is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference), . Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "Reference: \n",
    "- [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)\n",
    "- [rainbow-is-all-you-need](https://render.githubusercontent.com/view/ipynb?commit=032d11277cf2436853478a69ca5a4aba03202598&enc_url=68747470733a2f2f7261772e67697468756275736572636f6e74656e742e636f6d2f437572742d5061726b2f7261696e626f772d69732d616c6c2d796f752d6e6565642f303332643131323737636632343336383533343738613639636135613461626130333230323539382f30312e64716e2e6970796e62&nwo=Curt-Park%2Frainbow-is-all-you-need&path=01.dqn.ipynb&repository_id=191133946&repository_type=Repository#Replay-buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        \"\"\"Store the transition in buffer.\"\"\"\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We are going to use three different networks for policy, Q-function, and V-function. We use two Q-functions to mitigate positive bias and softly update V-function for stable learning. One interesting thing is that the policy network works as Tanh Normal distribution which enforces action bounds. (The details are descibed in Appendix C of [2].)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_layer_uniform(layer: nn.Linear, init_w: float = 3e-3) -> nn.Linear:\n",
    "    \"\"\"Init uniform parameters on the single layer.\"\"\"\n",
    "    layer.weight.data.uniform_(-init_w, init_w)\n",
    "    layer.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    return layer\n",
    "\n",
    "\n",
    "class Actor(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int,\n",
    "        log_std_min: float = -20,\n",
    "        log_std_max: float = 2,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "        \n",
    "        # set the log std range\n",
    "        self.log_std_min = log_std_min\n",
    "        self.log_std_max = log_std_max\n",
    "        \n",
    "        # set the hidden layers\n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        \n",
    "        # set log_std layer\n",
    "        self.log_std_layer = nn.Linear(128, out_dim)\n",
    "        self.log_std_layer = init_layer_uniform(self.log_std_layer)\n",
    "\n",
    "        # set mean layer\n",
    "        self.mu_layer = nn.Linear(128, out_dim)\n",
    "        self.mu_layer = init_layer_uniform(self.mu_layer)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        \n",
    "        # get mean\n",
    "        mu = self.mu_layer(x).tanh()\n",
    "        \n",
    "        # get std\n",
    "        log_std = self.log_std_layer(x).tanh()\n",
    "        log_std = self.log_std_min + 0.5 * (\n",
    "            self.log_std_max - self.log_std_min\n",
    "        ) * (log_std + 1)\n",
    "        std = torch.exp(log_std)\n",
    "        \n",
    "        # sample actions\n",
    "        dist = Normal(mu, std)\n",
    "        z = dist.rsample()\n",
    "        \n",
    "        # normalize action and log_prob\n",
    "        # see appendix C of [2]\n",
    "        action = z.tanh()\n",
    "        log_prob = dist.log_prob(z) - torch.log(1 - action.pow(2) + 1e-7)\n",
    "        log_prob = log_prob.sum(-1, keepdim=True)\n",
    "        \n",
    "        return action, log_prob\n",
    "    \n",
    "    \n",
    "class CriticQ(nn.Module):\n",
    "    def __init__(self, in_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(CriticQ, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "        self.out = init_layer_uniform(self.out)\n",
    "\n",
    "    def forward(\n",
    "        self, state: torch.Tensor, action: torch.Tensor\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = torch.cat((state, action), dim=-1)\n",
    "        x = F.relu(self.hidden1(x))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        value = self.out(x)\n",
    "        \n",
    "        return value\n",
    "    \n",
    "    \n",
    "class CriticV(nn.Module):\n",
    "    def __init__(self, in_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(CriticV, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "        self.out = init_layer_uniform(self.out)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        value = self.out(x)\n",
    "        \n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SAC Agent\n",
    "Here is a summary of SACAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|\\_target_soft_update| soft update from the local model to the target model.|\n",
    "|\\_plot              | plot the training progresses.                        |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SACAgent:\n",
    "    \"\"\"SAC agent interacting with environment.\n",
    "    \n",
    "    Attrtibutes:\n",
    "        actor (nn.Module): actor model to select actions\n",
    "        actor_optimizer (Optimizer): optimizer for training actor\n",
    "        vf (nn.Module): critic model to predict state values\n",
    "        vf_target (nn.Module): target critic model to predict state values\n",
    "        vf_optimizer (Optimizer): optimizer for training vf\n",
    "        qf_1 (nn.Module): critic model to predict state-action values\n",
    "        qf_2 (nn.Module): critic model to predict state-action values\n",
    "        qf_1_optimizer (Optimizer): optimizer for training qf_1\n",
    "        qf_2_optimizer (Optimizer): optimizer for training qf_2\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory\n",
    "        batch_size (int): batch size for sampling\n",
    "        gamma (float): discount factor\n",
    "        tau (float): parameter for soft target update\n",
    "        initial_random_steps (int): initial random action steps\n",
    "        policy_update_freq (int): policy update frequency\n",
    "        device (torch.device): cpu / gpu\n",
    "        target_entropy (int): desired entropy used for the inequality constraint\n",
    "        log_alpha (torch.Tensor): weight for entropy\n",
    "        alpha_optimizer (Optimizer): optimizer for alpha\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(\n",
    "        self,\n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        gamma: float = 0.99,\n",
    "        tau: float = 5e-3,\n",
    "        initial_random_steps: int = int(1e4),\n",
    "        policy_update_freq: int = 2,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "\n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.initial_random_steps = initial_random_steps\n",
    "        self.policy_update_freq = policy_update_freq\n",
    "\n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "        \n",
    "        # automatic entropy tuning\n",
    "        self.target_entropy = -np.prod((action_dim,)).item()  # heuristic\n",
    "        self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)\n",
    "        self.alpha_optimizer = optim.Adam([self.log_alpha], lr=3e-4)\n",
    "\n",
    "        # actor\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        \n",
    "        # v function\n",
    "        self.vf = CriticV(obs_dim).to(self.device)\n",
    "        self.vf_target = CriticV(obs_dim).to(self.device)\n",
    "        self.vf_target.load_state_dict(self.vf.state_dict())\n",
    "        \n",
    "        # q function\n",
    "        self.qf_1 = CriticQ(obs_dim + action_dim).to(self.device)\n",
    "        self.qf_2 = CriticQ(obs_dim + action_dim).to(self.device)\n",
    "\n",
    "        # optimizers\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=3e-4)\n",
    "        self.vf_optimizer = optim.Adam(self.vf.parameters(), lr=3e-4)\n",
    "        self.qf_1_optimizer = optim.Adam(self.qf_1.parameters(), lr=3e-4)\n",
    "        self.qf_2_optimizer = optim.Adam(self.qf_2.parameters(), lr=3e-4)\n",
    "        \n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # total steps count\n",
    "        self.total_step = 0\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "    \n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # if initial random action should be conducted\n",
    "        if self.total_step < self.initial_random_steps and not self.is_test:\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.actor(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            )[0].detach().cpu().numpy()\n",
    "            \n",
    "        self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "    \n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, float, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "    \n",
    "    def update_model(self) -> Tuple[torch.Tensor, ...]:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        \n",
    "        samples = self.memory.sample_batch()\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.FloatTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        new_action, log_prob = self.actor(state)\n",
    "        \n",
    "        # train alpha (dual problem)\n",
    "        alpha_loss = (\n",
    "            -self.log_alpha.exp() * (log_prob + self.target_entropy).detach()\n",
    "        ).mean()\n",
    "\n",
    "        self.alpha_optimizer.zero_grad()\n",
    "        alpha_loss.backward()\n",
    "        self.alpha_optimizer.step()\n",
    "        \n",
    "        alpha = self.log_alpha.exp()  # used for the actor loss calculation\n",
    "        \n",
    "        # q function loss\n",
    "        mask = 1 - done\n",
    "        q_1_pred = self.qf_1(state, action)\n",
    "        q_2_pred = self.qf_2(state, action)\n",
    "        v_target = self.vf_target(next_state)\n",
    "        q_target = reward + self.gamma * v_target * mask\n",
    "        qf_1_loss = F.mse_loss(q_1_pred, q_target.detach())\n",
    "        qf_2_loss = F.mse_loss(q_2_pred, q_target.detach())\n",
    "        \n",
    "        # v function loss\n",
    "        v_pred = self.vf(state)\n",
    "        q_pred = torch.min(\n",
    "            self.qf_1(state, new_action), self.qf_2(state, new_action)\n",
    "        )\n",
    "        v_target = q_pred - alpha * log_prob\n",
    "        vf_loss = F.mse_loss(v_pred, v_target.detach())\n",
    "        \n",
    "        if self.total_step % self.policy_update_freq == 0:\n",
    "            # actor loss\n",
    "            advantage = q_pred - v_pred.detach()\n",
    "            actor_loss = (alpha * log_prob - advantage).mean()\n",
    "            \n",
    "            # train actor\n",
    "            self.actor_optimizer.zero_grad()\n",
    "            actor_loss.backward()\n",
    "            self.actor_optimizer.step()\n",
    "        \n",
    "            # target update (vf)\n",
    "            self._target_soft_update()\n",
    "        else:\n",
    "            actor_loss = torch.zeros(1)\n",
    "            \n",
    "        # train Q functions\n",
    "        self.qf_1_optimizer.zero_grad()\n",
    "        qf_1_loss.backward()\n",
    "        self.qf_1_optimizer.step()\n",
    "\n",
    "        self.qf_2_optimizer.zero_grad()\n",
    "        qf_2_loss.backward()\n",
    "        self.qf_2_optimizer.step()\n",
    "        \n",
    "        qf_loss = qf_1_loss + qf_2_loss\n",
    "\n",
    "        # train V function\n",
    "        self.vf_optimizer.zero_grad()\n",
    "        vf_loss.backward()\n",
    "        self.vf_optimizer.step()\n",
    "        \n",
    "        return actor_loss.data, qf_loss.data, vf_loss.data, alpha_loss.data\n",
    "    \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        actor_losses, qf_losses, vf_losses, alpha_losses = [], [], [], []\n",
    "        scores = []\n",
    "        score = 0\n",
    "        \n",
    "        for self.total_step in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if (\n",
    "                len(self.memory) >= self.batch_size \n",
    "                and self.total_step > self.initial_random_steps\n",
    "            ):\n",
    "                losses = self.update_model()\n",
    "                actor_losses.append(losses[0])\n",
    "                qf_losses.append(losses[1])\n",
    "                vf_losses.append(losses[2])\n",
    "                alpha_losses.append(losses[3])\n",
    "            \n",
    "            # plotting\n",
    "            if self.total_step % plotting_interval == 0:\n",
    "                self._plot(\n",
    "                    self.total_step,\n",
    "                    scores, \n",
    "                    actor_losses, \n",
    "                    qf_losses, \n",
    "                    vf_losses, \n",
    "                    alpha_losses\n",
    "                )\n",
    "                \n",
    "        self.env.close()\n",
    "        \n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "    \n",
    "    def _target_soft_update(self):\n",
    "        \"\"\"Soft-update: target = tau*local + (1-tau)*target.\"\"\"\n",
    "        tau = self.tau\n",
    "        \n",
    "        for t_param, l_param in zip(\n",
    "            self.vf_target.parameters(), self.vf.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "    \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        actor_losses: List[float],\n",
    "        qf_losses: List[float],\n",
    "        vf_losses: List[float],\n",
    "        alpha_losses: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (151, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (152, \"actor_loss\", actor_losses),\n",
    "            (153, \"qf_loss\", qf_losses),\n",
    "            (154, \"vf_loss\", vf_losses),\n",
    "            (155, \"alpha_loss\", alpha_losses),\n",
    "        ]\n",
    "        \n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActionNormalizer(gym.ActionWrapper):\n",
    "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
    "\n",
    "    def action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = action * scale_factor + reloc_factor\n",
    "        action = np.clip(action, low, high)\n",
    "\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = (action - reloc_factor) / scale_factor\n",
    "        action = np.clip(action, -1.0, 1.0)\n",
    "\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)\n",
    "env = ActionNormalizer(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 50000\n",
    "memory_size = 100000\n",
    "batch_size = 128\n",
    "initial_random_steps = 10000\n",
    "\n",
    "agent = SACAgent(\n",
    "    env, memory_size, batch_size, initial_random_steps=initial_random_steps\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x360 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  -231.72002778923985\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "if IN_COLAB:\n",
    "    agent.env = gym.wrappers.Monitor(agent.env, \"videos\", force=True)\n",
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgQNAMVCLFKNSBXDEM\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderQNAMVCLFKNSBXDEM\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animQNAMVCLFKNSBXDEM.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animQNAMVCLFKNSBXDEM.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animQNAMVCLFKNSBXDEM.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQNAMVCLFKNSBXDEM.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQNAMVCLFKNSBXDEM.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQNAMVCLFKNSBXDEM.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQNAMVCLFKNSBXDEM.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQNAMVCLFKNSBXDEM.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQNAMVCLFKNSBXDEM.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animQNAMVCLFKNSBXDEM.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectQNAMVCLFKNSBXDEM\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgQNAMVCLFKNSBXDEM\";\n",
       "    var slider_id = \"_anim_sliderQNAMVCLFKNSBXDEM\";\n",
       "    var loop_select_id = \"_anim_loop_selectQNAMVCLFKNSBXDEM\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animQNAMVCLFKNSBXDEM = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if IN_COLAB:  # for colab\n",
    "    import base64\n",
    "    import glob\n",
    "    import io\n",
    "    import os\n",
    "\n",
    "    from IPython.display import HTML, display\n",
    "\n",
    "    def ipython_show_video(path: str) -> None:\n",
    "        \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "        if not os.path.isfile(path):\n",
    "            raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "        video = io.open(path, \"r+b\").read()\n",
    "        encoded = base64.b64encode(video)\n",
    "\n",
    "        display(HTML(\n",
    "            data=\"\"\"\n",
    "            <video alt=\"test\" controls>\n",
    "            <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "            </video>\n",
    "            \"\"\".format(encoded.decode(\"ascii\"))\n",
    "        ))\n",
    "\n",
    "    list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    print(latest_file)\n",
    "    ipython_show_video(latest_file)\n",
    "\n",
    "else:  # for jupyter\n",
    "    from matplotlib import animation\n",
    "    from JSAnimation.IPython_display import display_animation\n",
    "    from IPython.display import display\n",
    "\n",
    "\n",
    "    def display_frames_as_gif(frames):\n",
    "        \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "        patch = plt.imshow(frames[0])\n",
    "        plt.axis('off')\n",
    "\n",
    "        def animate(i):\n",
    "            patch.set_data(frames[i])\n",
    "\n",
    "        anim = animation.FuncAnimation(\n",
    "            plt.gcf(), animate, frames = len(frames), interval=50\n",
    "        )\n",
    "        display(display_animation(anim, default_mode='loop'))\n",
    "\n",
    "\n",
    "    # display \n",
    "    display_frames_as_gif(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pgayn",
   "language": "python",
   "name": "pgayn"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
